import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

# Define the cost function
def cost_function(x, y, z):
    return x**2 + y**2 + z**2

# Define the gradient of the cost function
def gradient(x, y, z):
    grad_x = 2 * x
    grad_y = 2 * y
    grad_z = 2 * z
    return grad_x, grad_y, grad_z

# Initialize starting point and hyperparameters
x, y, z = 5.0, 5.0, 5.0
learning_rate = 0.1
num_iterations = 100

# Lists to store the trajectory
x_trajectory, y_trajectory, z_trajectory = [], [], []

# Gradient Descent
for i in range(num_iterations):
    grad_x, grad_y, grad_z = gradient(x, y, z)
    x -= learning_rate * grad_x
    y -= learning_rate * grad_y
    z -= learning_rate * grad_z
    
    x_trajectory.append(x)
    y_trajectory.append(y)
    z_trajectory.append(z)

# Create a 3D meshgrid for the cost function surface
x_range = np.linspace(-6, 6, 100)
y_range = np.linspace(-6, 6, 100)
z_range = np.linspace(-6, 6, 100)
X, Y, Z = np.meshgrid(x_range, y_range, z_range)
cost_surface = cost_function(X, Y, Z)

# Create a 3D scatter plot of the trajectory with a color gradient
fig = plt.figure(figsize=(10, 8))
ax = fig.add_subplot(111, projection='3d')

# Plot the cost function surface as a wireframe
ax.plot_wireframe(X, Y, cost_surface, cmap='viridis', alpha=0.3)

# Create a color gradient for the trajectory
colors = np.arange(len(x_trajectory))

# Plot the trajectory of gradient descent with a color gradient
scatter = ax.scatter(x_trajectory, y_trajectory, z_trajectory, c=colors, cmap='cool', marker='o', s=50)
ax.scatter([0], [0], [0], color='green', s=100, label='Optimal Solution')

ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Cost Function')
ax.set_title('Gradient Descent in 3D')
plt.legend()
plt.colorbar(scatter, label='Iteration')
plt.show()

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[5], line 47
     44 ax = fig.add_subplot(111, projection='3d')
     46 # Plot the cost function surface as a wireframe
---> 47 ax.plot_wireframe(X, Y, cost_surface, cmap='viridis', alpha=0.3)
     49 # Create a color gradient for the trajectory
     50 colors = np.arange(len(x_trajectory))

File C:\ProgramData\anaconda3\Lib\site-packages\mpl_toolkits\mplot3d\axes3d.py:1732, in Axes3D.plot_wireframe(self, X, Y, Z, **kwargs)
   1730 had_data = self.has_data()
   1731 if Z.ndim != 2:
-> 1732     raise ValueError("Argument Z must be 2-dimensional.")
   1733 # FIXME: Support masked arrays
   1734 X, Y, Z = np.broadcast_arrays(X, Y, Z)

ValueError: Argument Z must be 2-dimensional.

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

# Define a quadratic function
def mk_quad(a, b):
    x = np.linspace(0, 4, 50)
    return a * x**2 + b

# Define the Mean Absolute Error (MAE) function
def mae_np(pred, target):
    return np.mean(np.abs(pred - target))

# Define the loss function
def loss(a, b):
    f = mk_quad(a, b)
    return mae_np(f, y)

# Create a grid of parameter values
grid_x = np.linspace(0, 4, 50)
grid_y = np.linspace(0, 4, 50)
X, Y = np.meshgrid(grid_x, grid_y)

# Calculate the loss for each parameter combination
Z = np.zeros((50, 50))
for x1 in range(len(X)):
    for y1 in range(len(Y)):
        Z[x1][y1] = loss(X[x1][y1], Y[x1][y1])

# Define a function to plot the loss in 3D
def plot_loss_3d():
    fig = plt.figure()
    ax = plt.axes(projection='3d')
    ax.set_title("Loss Function")
    ax.set_xlabel("a range")
    ax.set_ylabel("b range")
    ax.set_zlabel("Loss")
    ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap='jet', edgecolor='none')

# Call the function to plot the loss
plot_loss_3d()

plt.show()

import numpy as np
from matplotlib import pyplot as plt
from matplotlib import animation
from mpl_toolkits.mplot3d import Axes3D



# Create a figure and a 3D Axes
fig = plt.figure(figsize=(12,10))
ax = Axes3D(fig)
ax.set_xlabel('Rooms', fontsize = 15)
ax.set_ylabel('Population', fontsize = 15)
ax.set_zlabel('Price', fontsize = 15)

plt.close()

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from matplotlib import animation

# Sample data
np.random.seed(0)
xs = np.random.rand(50, 2)
ys = xs[:, 0] + 2 * xs[:, 1] + np.random.rand(50)

# Initialize figure and 3D plot
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')

# Initialize parameters
Theta_0 = 0.0
Theta_1 = 0.0

def init():
    ax.scatter(xs[:, 0], xs[:, 1], ys, c='C6', marker='o', alpha=0.6)
    x0, x1 = np.meshgrid(xs[:, 0], xs[:, 1])
    yp = Theta_0 * x0 + Theta_1 * x1
    ax.plot_wireframe(x0, x1, yp, rcount=200, ccount=200, linewidth=0.5, color='C9', alpha=0.5)
    ax.legend(fontsize=15, labels=['Data points', 'Hyperplane'])
    return fig,

def animate(i):
    ax.view_init(elev=10., azim=i)
    return fig,

# Animate
anim = animation.FuncAnimation(fig, animate, init_func=init,
                               frames=360, interval=20, blit=True)
anim.save('animation.gif', writer='pillow', fps=30)
plt.close()

import io
import base64
from IPython.display import HTML

filename = 'animation.gif'


HTML(data='''<img src="data:image/gif;base64,{0}" type="gif" />'''.format(encoded.decode('ascii')))

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

# Generate some sample 3D data for demonstration
np.random.seed(0)
X1 = 2 * np.random.rand(100, 1)
X2 = 3 * np.random.rand(100, 1)
y = 4 + 2 * X1 + 3 * X2 + np.random.rand(100, 1)

# Initialize the model parameters
theta0 = np.random.rand(1)
theta1 = np.random.rand(1)
theta2 = np.random.rand(1)

# Set hyperparameters
learning_rate = 0.01
num_iterations = 1000

# Lists to store the history of parameter values for plotting
theta0_history = []
theta1_history = []
theta2_history = []

# Perform gradient descent
for iteration in range(num_iterations):
    # Calculate the predicted values (hypothesis)
    y_pred = theta0 + theta1 * X1 + theta2 * X2

    # Calculate the gradients
    gradient_theta0 = np.sum(y_pred - y)
    gradient_theta1 = np.sum((y_pred - y) * X1)
    gradient_theta2 = np.sum((y_pred - y) * X2)

    # Update the model parameters using gradient descent
    theta0 = theta0 - learning_rate * gradient_theta0
    theta1 = theta1 - learning_rate * gradient_theta1
    theta2 = theta2 - learning_rate * gradient_theta2

    # Store the parameter values for plotting
    theta0_history.append(theta0[0])
    theta1_history.append(theta1[0])
    theta2_history.append(theta2[0])

# Print the final model parameters
print("Theta0 (Intercept):", theta0)
print("Theta1 (Slope for X1):", theta1)
print("Theta2 (Slope for X2):", theta2)

# Create a 3D scatter plot of the data points
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.scatter(X1, X2, y, label='Data Points', c='b', marker='o')

# Create a meshgrid for the plane representing the linear regression model
x1_plane, x2_plane = np.meshgrid(np.linspace(X1.min(), X1.max(), 50), np.linspace(X2.min(), X2.max(), 50))
y_plane = theta0 + theta1 * x1_plane + theta2 * x2_plane

# Plot the linear regression plane
ax.plot_surface(x1_plane, x2_plane, y_plane, alpha=0.5, cmap='viridis')

ax.set_xlabel('X1')
ax.set_ylabel('X2')
ax.set_zlabel('y')
ax.set_title('3D Linear Regression using Gradient Descent')
plt.legend()
plt.grid(True)

# Plot the trajectory of the gradient descent in 3D
fig2 = plt.figure()
ax2 = fig2.add_subplot(111, projection='3d')
ax2.plot(theta0_history, theta1_history, theta2_history, label='Parameter Trajectory')
ax2.set_xlabel('Theta0')
ax2.set_ylabel('Theta1')
ax2.set_zlabel('Theta2')
ax2.set_title('Gradient Descent Trajectory in 3D')
plt.legend()
plt.grid(True)

plt.show()

C:\ProgramData\anaconda3\Lib\site-packages\numpy\core\fromnumeric.py:86: RuntimeWarning: overflow encountered in reduce
  return ufunc.reduce(obj, axis, dtype, out, **passkwargs)
C:\Users\hp\AppData\Local\Temp\ipykernel_7760\957577516.py:36: RuntimeWarning: invalid value encountered in subtract
  theta0 = theta0 - learning_rate * gradient_theta0
C:\Users\hp\AppData\Local\Temp\ipykernel_7760\957577516.py:37: RuntimeWarning: invalid value encountered in subtract
  theta1 = theta1 - learning_rate * gradient_theta1
C:\Users\hp\AppData\Local\Temp\ipykernel_7760\957577516.py:38: RuntimeWarning: invalid value encountered in subtract
  theta2 = theta2 - learning_rate * gradient_theta2

Theta0 (Intercept): [nan]
Theta1 (Slope for X1): [nan]
Theta2 (Slope for X2): [nan]

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

# Generate some sample 3D data for demonstration
np.random.seed(0)
X1 = 2 * np.random.rand(100, 1)
X2 = 3 * np.random.rand(100, 1)
y = 4 + 2 * X1 + 3 * X2 + np.random.rand(100, 1)

# Initialize the model parameters
theta0 = np.random.rand(1)
theta1 = np.random.rand(1)
theta2 = np.random.rand(1)

# Set hyperparameters
learning_rate = 0.01
num_iterations = 1000

# Lists to store the history of parameter values for plotting
theta0_history = []
theta1_history = []
theta2_history = []
cost_history = []

# Perform gradient descent
for iteration in range(num_iterations):
    # Calculate the predicted values (hypothesis)
    y_pred = theta0 + theta1 * X1 + theta2 * X2

    # Calculate the gradients
    gradient_theta0 = np.sum(y_pred - y)
    gradient_theta1 = np.sum((y_pred - y) * X1)
    gradient_theta2 = np.sum((y_pred - y) * X2)

    # Update the model parameters using gradient descent
    theta0 = theta0 - learning_rate * gradient_theta0
    theta1 = theta1 - learning_rate * gradient_theta1
    theta2 = theta2 - learning_rate * gradient_theta2

    # Calculate the cost function (mean squared error)
    cost = np.mean((y_pred - y) ** 2)
    
    # Store the parameter values and cost for plotting
    theta0_history.append(theta0[0])
    theta1_history.append(theta1[0])
    theta2_history.append(theta2[0])
    cost_history.append(cost)

# Create a grid of parameter values for plotting the cost function
theta0_vals = np.linspace(-2, 6, 100)
theta1_vals = np.linspace(-2, 6, 100)
theta0_grid, theta1_grid = np.meshgrid(theta0_vals, theta1_vals)
cost_surface = np.zeros_like(theta0_grid)

for i in range(len(theta0_vals)):
    for j in range(len(theta1_vals)):
        cost_surface[i, j] = np.mean((y - (theta0_vals[i] + theta1_vals[j] * X1 + theta2 * X2))**2)

# Print the final model parameters
print("Theta0 (Intercept):", theta0)
print("Theta1 (Slope for X1):", theta1)
print("Theta2 (Slope for X2):", theta2)

# Create a 3D scatter plot of all data points
fig = plt.figure(figsize=(12, 8))
ax = fig.add_subplot(111, projection='3d')
ax.scatter(X1, X2, y, label='Data Points', marker='o')

# Create a meshgrid for the plane representing the linear regression model
x1_plane, x2_plane = np.meshgrid(np.linspace(X1.min(), X1.max(), 50), np.linspace(X2.min(), X2.max(), 50))
y_plane = theta0 + theta1 * x1_plane + theta2 * x2_plane

# Plot the linear regression plane
ax.plot_surface(x1_plane, x2_plane, y_plane, alpha=0.5, cmap='viridis')

# Plot the trajectory of the gradient descent in parameter space
ax.plot(theta0_history, theta1_history, theta2_history, label='Parameter Trajectory', c='r', linewidth=2)

ax.set_xlabel('X1')
ax.set_ylabel('X2')
ax.set_zlabel('y')
ax.set_title('3D Linear Regression using Gradient Descent')
plt.legend()
plt.grid(True)

# Create a subplot for the cost function surface
fig2 = plt.figure(figsize=(10, 6))
ax2 = fig2.add_subplot(111, projection='3d')
ax2.plot_surface(theta0_grid, theta1_grid, cost_surface, cmap='viridis', alpha=0.7)
ax2.set_xlabel('Theta0')
ax2.set_ylabel('Theta1')
ax2.set_zlabel('Cost Function')
ax2.set_title('Cost Function Surface')
plt.grid(True)

plt.show()

C:\Users\hp\AppData\Local\Temp\ipykernel_7760\940254435.py:42: RuntimeWarning: overflow encountered in square
  cost = np.mean((y_pred - y) ** 2)
C:\Users\hp\AppData\Local\Temp\ipykernel_7760\940254435.py:37: RuntimeWarning: invalid value encountered in subtract
  theta0 = theta0 - learning_rate * gradient_theta0
C:\Users\hp\AppData\Local\Temp\ipykernel_7760\940254435.py:38: RuntimeWarning: invalid value encountered in subtract
  theta1 = theta1 - learning_rate * gradient_theta1
C:\Users\hp\AppData\Local\Temp\ipykernel_7760\940254435.py:39: RuntimeWarning: invalid value encountered in subtract
  theta2 = theta2 - learning_rate * gradient_theta2

Theta0 (Intercept): [nan]
Theta1 (Slope for X1): [nan]
Theta2 (Slope for X2): [nan]